home *** CD-ROM | disk | FTP | other *** search
/ Shareware Extravaganza - Disc 1 / ShareWare Extravaganza 1 of 4 (The Ultimate Shareware Company).iso / grprogs / picutil.exe / ALTER.SRC / SUB.ASM < prev   
Assembly Source File  |  1986-06-25  |  9KB  |  240 lines
  1. ;╔═════════════════════════════════════════════════════════════════════════════╗
  2. ;║ ░░░░░░░░░░░ PROGRAM = SUB.ASM ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║
  3. ;╚═════════════════════════════════════════════════════════════════════════════╝
  4. CSEG           SEGMENT PUBLIC BYTE
  5.            ASSUME  CS:CSEG,DS:CSEG
  6.            INCLUDE PUBLICS.EQU
  7.  
  8.            EXTRN   BUFF_SIZE:WORD
  9.            EXTRN   DISK_BUFFER:DWORD
  10.            EXTRN   HANDLE_IN:WORD
  11.            EXTRN   HANDLE_OUT:WORD
  12.            EXTRN   FLAGS:WORD
  13.  
  14. DIVISOR        DW      0,1
  15. TEN           DW      10,100,1000,10000
  16. ;╔═════════════════════════════════════════════════════════════════════════════╗
  17. ;║ ░░░░░░░░░░░ ASCII TO BINARY ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║
  18. ;╚═════════════════════════════════════════════════════════════════════════════╝
  19. ;┌─────────────────────────────────────────────────────────────────────────────┐
  20. ;│        DS:SI = START OF ASCII STRING                       │
  21. ;│           AX = NUMBER OF CHARACTER IN STRING (1-5)                │
  22. ;├─────────────────────────────────────────────────────────────────────────────┤
  23. ;│           AX = RETURNS BINARY NUMBER                       │
  24. ;└─────────────────────────────────────────────────────────────────────────────┘
  25.            PUBLIC  ASC2BIN
  26. ASC2BIN        PROC    NEAR
  27.  
  28.            PUSH    BX               ;SAVE REGISTERS
  29.            PUSH    CX               ;
  30.            PUSH    DX               ;
  31.            PUSH    SI               ;
  32.  
  33.            SHL     AX,1               ;MAKE INTO WORD OFFSET
  34.            MOV     BX,AX               ;
  35.            PUSH    SI               ;
  36.            MOV     SI,OFFSET DIVISOR       ;
  37.            MOV     CX,[SI+BX]           ;DIVISOR
  38.            POP     SI               ;
  39.            XOR     BX,BX               ;CLEAR BINARY HOLD REGISTER
  40.                            ;
  41. ASC100:                        ;
  42.            LODSB                   ;GET ASCII NUMBER
  43.            AND     AL,0FH               ;STRIP ASCII PART
  44.            XOR     AH,AH               ;
  45.            MUL     CX               ;
  46.            ADD     BX,AX               ;
  47.            CMP     CX,1               ;DONE?
  48.            JE      ASC300
  49.            MOV     AX,CX               ;GET DIVISOR
  50.            XOR     DX,DX               ;
  51.            DIV     TEN               ;DIVIDE IT BY TEN
  52.            MOV     CX,AX               ;PUT BACK IN DX
  53.            JMP     SHORT ASC100           ;
  54. ASC300:
  55.            MOV     AX,BX               ;PUT BINARY NUMBER IN AX
  56.            POP     SI               ;RESTORE REGISTERS
  57.            POP     DX               ;
  58.            POP     CX               ;
  59.            POP     BX               ;
  60.            RET
  61. ASC2BIN        ENDP
  62. ;╔═════════════════════════════════════════════════════════════════════════════╗
  63. ;║ ░░░░░░░░░░░ BINARY TO ASCII ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║
  64. ;╚═════════════════════════════════════════════════════════════════════════════╝
  65. ;┌─────────────────────────────────────────────────────────────────────────────┐
  66. ;│           AX = BINARY NUMBER                           │
  67. ;│           BX = NUMBER OF ASCII CHARACTERS TO FILL    (1-5)               │
  68. ;│        ES:DI = WHERE TO PUT ASCII STRING                       │
  69. ;└─────────────────────────────────────────────────────────────────────────────┘
  70.            PUBLIC  BIN2ASC
  71. BIN2ASC        PROC    NEAR
  72.  
  73.            PUSH    AX               ;SAVE REGISTERS
  74.            PUSH    BX               ;
  75.            PUSH    CX               ;
  76.            PUSH    DX               ;
  77.            PUSH    DI               ;
  78.            PUSH    SI               ;
  79.            PUSH    ES
  80.  
  81.            SHL     BX,1               ;MAKE INTO WORD OFFSET
  82.            MOV     SI,OFFSET DIVISOR       ;
  83.            MOV     CX,[SI+BX]           ;DIVISOR
  84.  
  85. BIN100:                        ;
  86.            XOR     DX,DX               ;CLEAR DX FOR DIVIDE
  87.            DIV     CX               ;
  88.            ADD     AL,'0'                  ;
  89.            STOSB                   ;
  90.            CMP     CX,1               ;
  91.            JE      BIN300               ;
  92.            PUSH    DX               ;SAVE REMAINDER
  93.            MOV     AX,CX               ;GET DIVISOR
  94.            XOR     DX,DX               ;
  95.            DIV     TEN               ;DIVIDE IT BY TEN
  96.            MOV     CX,AX               ;PUT BACK IN DX
  97.            POP     AX               ;GET REMAINDER IN AX
  98.            JMP     SHORT BIN100           ;
  99. BIN300:
  100.            POP     ES
  101.            POP     SI               ;RESTORE REGISTERS
  102.            POP     DI               ;
  103.            POP     DX               ;
  104.            POP     CX               ;
  105.            POP     BX               ;
  106.            POP     AX               ;
  107.            RET
  108. BIN2ASC        ENDP
  109. ;╔═════════════════════════════════════════════════════════════════════════════╗
  110. ;║ ░░░░░░░░░░░ WRITE_DATA ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║
  111. ;╚═════════════════════════════════════════════════════════════════════════════╝
  112. ;┌─────────────────────────────────────────────────────────────────────────────┐
  113. ;│           CX = BYTE COUNT                               │
  114. ;│           BX = HANDLE OF FILE                           │
  115. ;└─────────────────────────────────────────────────────────────────────────────┘
  116.            PUBLIC  WRITE_DATA
  117. WRITE_DATA     PROC    NEAR
  118.  
  119.            PUSH    DS
  120.            LDS     DX,CS:DISK_BUFFER
  121.            MOV     AH,40H
  122.            INT     21H
  123.            POP     DS
  124.            RET
  125.  
  126. WRITE_DATA     ENDP
  127. ;╔═════════════════════════════════════════════════════════════════════════════╗
  128. ;║ ░░░░░░░░░░░ READ_DATA ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║
  129. ;╚═════════════════════════════════════════════════════════════════════════════╝
  130. ;┌─────────────────────────────────────────────────────────────────────────────┐
  131. ;│           CX = BYTE COUNT                               │
  132. ;│           BX = HANDLE OF FILE                           │
  133. ;└─────────────────────────────────────────────────────────────────────────────┘
  134.            PUBLIC  READ_DATA
  135. READ_DATA      PROC    NEAR
  136.  
  137.            PUSH    DS
  138.            MOV     AH,3FH
  139.            LDS     DX,CS:DISK_BUFFER
  140.            INT     21H
  141.            POP     DS
  142.            RET
  143.  
  144. READ_DATA      ENDP
  145. ;╔═════════════════════════════════════════════════════════════════════════════╗
  146. ;║ ░░░░░░░░░░░ READ_RAW ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║
  147. ;╚═════════════════════════════════════════════════════════════════════════════╝
  148. ;┌─────────────────────────────────────────────────────────────────────────────┐
  149. ;│           READ [BUFF_SIZE] BYTES INTO DISK_BUFFER                   │
  150. ;│           ON RETURN AX CONTAINS NUMBER OF BYTES READ               │
  151. ;│           AND CARRY WILL BE SET IF THIS IS END OF FILE               │
  152. ;└─────────────────────────────────────────────────────────────────────────────┘
  153.            PUBLIC  READ_RAW
  154. READ_RAW       PROC    NEAR
  155.  
  156.            PUSH    BX
  157.            PUSH    CX
  158.            PUSH    DX
  159. MR100:
  160.            MOV     BX,CS:HANDLE_IN          ;
  161.            MOV     CX,BUFF_SIZE           ;
  162.            CALL    READ_DATA           ;READ 8000H BYTES
  163.            CMP     AX,BUFF_SIZE           ;DONE?
  164.            JE      MR300               ;NO..
  165. MR200:
  166.            STC
  167.            JMP     SHORT MR400
  168. MR300:
  169.            CLC
  170. MR400:
  171.            PUSHF
  172.            TEST    FLAGS,INVERT_IN
  173.            JZ      MR500
  174.            CALL    INVERT_BUFF
  175. MR500:
  176.            POPF
  177.            POP     DX
  178.            POP     CX
  179.            POP     BX
  180.            RET
  181.  
  182. READ_RAW       ENDP
  183. ;╔═════════════════════════════════════════════════════════════════════════════╗
  184. ;║ ░░░░░░░░░░░ WRITE_RAW ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║
  185. ;╚═════════════════════════════════════════════════════════════════════════════╝
  186. ;┌─────────────────────────────────────────────────────────────────────────────┐
  187. ;│           AX = NUMBER OF BYTES TO WRITE                       │
  188. ;│           COPIES DATA FROM DISK_BUFFER TO DISK                   │
  189. ;└─────────────────────────────────────────────────────────────────────────────┘
  190.            PUBLIC  WRITE_RAW
  191. WRITE_RAW      PROC    NEAR
  192.  
  193.            PUSH    AX               ;SAVE REGISTERS
  194.            PUSH    BX               ;
  195.            PUSH    CX               ;
  196.            PUSH    DX               ;
  197.  
  198.            TEST    FLAGS,INVERT_OUT
  199.            JZ      WR100
  200.            CALL    INVERT_BUFF
  201. WR100:
  202.            MOV     CX,AX               ;NUMBER OF BYTES TO WRITE
  203.            MOV     BX,CS:HANDLE_OUT       ;
  204.            CALL    WRITE_DATA           ;WRITE IN
  205.  
  206.            CLC
  207.            POP     DX              ;RESTORE REGISTERS
  208.            POP     CX              ;
  209.            POP     BX              ;
  210.            POP     AX              ;
  211.            RET
  212.  
  213. WRITE_RAW      ENDP
  214. ;╔═════════════════════════════════════════════════════════════════════════════╗
  215. ;║ ░░░░░░░░░░░ INVERT BUFFER ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░ ║
  216. ;╚═════════════════════════════════════════════════════════════════════════════╝
  217. INVERT_BUFF    PROC    NEAR
  218.            PUSH    CX
  219.            PUSH    DI
  220.            PUSH    ES
  221.  
  222.            MOV     CX,4000H
  223.            LES     DI,CS:DISK_BUFFER
  224. IB100:
  225.            NOT     WORD PTR ES:[DI]
  226.            INC     DI
  227.            INC     DI
  228.            LOOP    IB100
  229.  
  230.            POP     ES
  231.            POP     DI
  232.            POP     CX
  233.            RET
  234. INVERT_BUFF    ENDP
  235. ;╔═════════════════════════════════════════════════════════════════════════════╗
  236. ;╚═════════════════════════════════════════════════════════════════════════════╝
  237. CSEG           ENDS
  238.            END
  239.  
  240.